/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Main;

import Grafos.*;
import Simulacion.Simulator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;

/**
 *
 * @author Jonathan L.
 */
public class IngresoDatos {
    ArrayList<ComponenteRed> vertices = new ArrayList<ComponenteRed>();
    Graph<ComponenteRed, Double> graph = new GraphMatrixUndirected<ComponenteRed, Double>(vertices.size());
    Dialogos dialogos= new Dialogos();
    String error = dialogos.error;
    String eEx = dialogos.eEx;
    private String nombreRed;
    private int a = 0;
    private int tipoE=0;
    private int ingresoC=0;
    private int tipoDesk;
    private int tipoLap;
    private int cantC;
    private int cEcono, peso;
    int comImp;
    int comRed;
    int tCon;
    private String nombreE, equipo1, equipo2;
    int cCon;
    int cCon1;
    int eCon1;
    int eCon2;
    int vRed;
    private int unica;
    Scanner tecString = new Scanner(System.in);
    
    
    /**
     * Procedimiento para ingresar un número, con su respecta programación defensiva.
     * @param min
     * @param max
     */
    public void ingresarInt(int min, int max){
        System.out.println("\nIngrese su opción: ");
        // Verificar que la opción ingresada sea un número y no un String.
        try{
            Scanner tecInt = new Scanner(System.in);
            a=tecInt.nextInt();           
            if(a<min||a>max){
                System.out.println(error);
                a=0;
            }
        }catch(Exception e){
            System.out.println();
            a=0;
        }
    }
    
    /**
     * Procedimiento para ingresar el nombre de la red.
     */
    public void ingresarNombreG(){
        dialogos.nombreRed();
        try{
            Scanner tecString = new Scanner(System.in);
            nombreRed=tecString.next();
            
        }catch(Exception e){
            System.out.println(eEx);
        }
    }

    /**
     * Obtiene el nombre de la red.
     * @return nombreRed
     */
    public String getNombreRed() {
        return nombreRed;
    }
    
    /**
     * Procedimiento para ingresar números, con programación defensiva.
     * @param min
     * @param max
     */
    public void ingresoGeneral(int min, int max){
        //int ingreso;
        try{
            Scanner tecInt = new Scanner(System.in);
            unica = tecInt.nextInt();
            if(unica<min||unica>max){
                System.out.println(error);
                unica=0;
            }
        }catch(Exception e){
            System.out.println(eEx);
            unica=0;
        }
    }
    
    /**
     * Procedimiento para ingresar la cantidad de computadoras que existirán en la 
     * red, llama a setCantCompus(int ingreso) para fijar el límite de computadoras.
     */
    public void ingresarCantComputadoras(){
        int ingreso;
        if(ingresoC==1){
            dialogos.opcionCantCompC();
        }else dialogos.opcionCantCompG();
        try{
            Scanner tecInt = new Scanner(System.in);
            ingreso = tecInt.nextInt();
            if(ingreso<0||ingreso>2){
                System.out.println(error);
                ingreso=0;
            }
            unica=ingreso;
            setCantCompus(unica);
        }catch(Exception e){
            System.out.println(eEx);
            ingreso=0;
        }           
    }
    
    /*
     * Procedimiento que establece el límite de computadoras a ingresar según el 
     * tipo de red que se quiera realizar.
     */
    private void setCantCompus(int ingreso){
        if(tipoE==1){
            if(ingreso==1){
            cantC=8;
            }else cantC=16;
        }else{
            if(ingreso==1){
                cantC=24;
            }else cantC=48;
        }
        
    }
    
    /**
     * Procedimiento para ingresar la cantidad de desktops en la red.
     */
    public void ingresarTipoDesktop(){
        dialogos.opcionDesktop();
        try{
            Scanner tecInt = new Scanner(System.in);
            tipoDesk = tecInt.nextInt();
            if(tipoDesk<0||tipoDesk>cantC){
                System.out.println(error);
                unica=-1;
            }
        }catch(Exception e){
            System.out.println(eEx);
            unica=-1;
        }           
    }
    
    /**
     * Procedimiento para ingresar la cantidad de laptops en la red.
     */
    public void ingresarTipoLaptop(){
        dialogos.opcionLaptop();
        try{
            Scanner tecInt = new Scanner(System.in);
            tipoLap=unica = tecInt.nextInt();
            if(tipoLap<0||tipoLap>(cantC-tipoDesk)){
                System.out.println(error);
                System.out.println("Solamente puede ingresar "+ (cantC-tipoDesk)+" computadoras.");
                unica=-1;
            }
        }catch(Exception e){
            System.out.println(eEx);
            unica=-1;
        }           
    }
    
    /**
     * Procedimiento para ingresar entre economía u óptimo desempeño.
     */
    public void ingresarEcono(){
        dialogos.opcionEcono();
        try{
            Scanner tecInt = new Scanner(System.in);
            cEcono = tecInt.nextInt();
            if(cEcono<0||cEcono>2){
                System.out.println(error);
                cEcono=0;
            }
        }catch(Exception e){
            System.out.println(eEx);
            cEcono=0;
        }
    }
    
    /**
     * Procedimiento para ingresar el nombre de la computadora de la red.
     */
    public void ingresarComputadora(){
        dialogos.agregarComImp2();
        try{
            Scanner tecString = new Scanner(System.in);
            nombreE = tecString.next();
             if(nombreE=="0"){
                unica=-1;
            }
            unica=1;
        }catch(Exception e){
            System.out.println(eEx);
            unica=-1;
        }
    }
    
    /**
     * Procedimiento para ingresar el tipo de componente de red.
     */
    public void ingresarComRedM(){
        dialogos.agregarComRedM();
        try{
            Scanner tecInt = new Scanner(System.in);
            comRed=unica = tecInt.nextInt();
            if(comRed<0||comRed>10){
                System.out.println(error);
                comRed=0;
            }
            if (comRed==10){
                return;
            }
        }catch(Exception e){
            System.out.println(eEx);
            comRed=0;
        }
    }
    
    /**
     * Controla el ingreso de los equipos a conectar.
     * @param max
     */
    public void ingresarEquiposC(int max){
        cCon=-1;
        dialogos.agregarConexion1();
        while(cCon==-1){
        try{
            Scanner tecInt = new Scanner(System.in);
            cCon = tecInt.nextInt();
            if(cCon<0||cCon>max){
                System.out.println(error);
                cCon=-1;
            }
        }catch(Exception e){
            System.out.println(eEx);
            cCon=-1;
        }
        }
        dialogos.agregarConexion2();
        cCon1=-1;
        while(cCon1==-1){
        try{
            Scanner tecInt = new Scanner(System.in);
            cCon1 = tecInt.nextInt();
            if(cCon1==cCon || cCon1<0 || cCon1>max){
                System.out.println(error);
                cCon1=-1;
            }
        }catch(Exception e){
            System.out.println(eEx);
            cCon1=-1;
        }
        }
    }

    /**
     * Procedimiento para ingresar los equipos de los que se desea eliminar
     * la conexión.
     * @param max
     */
    public void ingresarEConexion(int max){
        dialogos.agregarEConexion1();
        while(eCon1==-1){
        try{
            Scanner tecInt = new Scanner(System.in);
            eCon1 = tecInt.nextInt();
            if(eCon1<0||eCon1>max){
                System.out.println(error);
                eCon1=-1;
            }
        }catch(Exception e){
            System.out.println(eEx);
            eCon1=-1;
        }
        }
        dialogos.agregarEConexion2();
        while(eCon2==-1){
        try{
            Scanner tecInt = new Scanner(System.in);
            eCon2 = tecInt.nextInt();
            if(eCon2==eCon1||eCon2<0||eCon2>max){
                System.out.println(error);
                eCon2=-1;
            }
        }catch(Exception e){
            System.out.println(eEx);
            eCon2=-1;
        }
        }
    }
    
    /**
     * Procedimiento para devolver el tipo de simulación que se desea realizar.
     * @param graph
     * @param nombre
     * @return vRed
     */
    public int ingresarVelT(ArrayList<Graph> graph, ArrayList<String> nombre){
        Iterator <ComponenteRed> viter;
        boolean invalido;
        
        int index=0;
        
        do{
            try{
                dialogos.velocidadT();
                Scanner tecString = new Scanner(System.in);
                Scanner tecInt = new Scanner(System.in);
                vRed = tecInt.nextInt();
                if(vRed<0||vRed>2){
                    System.out.println(error);
                    vRed=0;
                }
                invalido = false;
            }catch(Exception e){
                System.out.println(eEx);
                vRed=0;
                invalido = true;
            }
        }while(invalido);
        
        
        invalido = true;
        do{
            dialogos.velocidadTR();
            String red = tecString.next();
            for (int x=0; x<graph.size(); x++){
                if (nombre.get(x).equalsIgnoreCase(red)){
                    invalido = false;
                    this.graph = graph.get(x);
                    index = x;
                }  
            }
            if (invalido){dialogos.errorVelocidadTR();}
        } while(invalido);
        
  
        if(vRed==2){
            invalido = true;
            do{
                dialogos.velocidadT1();
                equipo1=tecString.next(); 
                viter = graph.get(index).iterator();
                while (viter.hasNext()){
                    ComponenteRed v = viter.next();
                        if (v.iscompu){
                            if (v.getNombreComponente().equalsIgnoreCase(equipo1)){
                                invalido = false;
                            } 
                       }               
                }
                if (invalido){dialogos.errorVelocidadT();}
            } while(invalido);
            
            invalido = true;
            do{
                dialogos.velocidadT2();
                equipo2=tecString.next(); 
                viter = graph.get(index).iterator();
                while (viter.hasNext()){
                    ComponenteRed v = viter.next();
                        if (v.iscompu){
                            if (v.getNombreComponente().equalsIgnoreCase(equipo1)){
                                invalido = false;
                            } 
                       }               
                }
                if (invalido){dialogos.errorVelocidadT();}
            } while(invalido);
            
            do{
                try{
                    dialogos.velocidadT4();
                    Scanner tecInt = new Scanner(System.in);
                    peso = tecInt.nextInt();
                    if(peso<0||peso>1000){
                        System.out.println("ERROR, Tamaño no Permitido.");
                        peso=0;
                    }
                    invalido = false;
                }catch(Exception e){
                    System.out.println(eEx);
                    invalido = true;
                }
            }while(invalido);
          
        }else{
            invalido = true;
            do{
                dialogos.velocidadT3();
                equipo1=tecString.next(); 
                viter = graph.get(index).iterator();
                while (viter.hasNext()){
                    ComponenteRed v = viter.next();
                        if (v.iscompu){
                            if (v.getNombreComponente().equalsIgnoreCase(equipo1)){
                                invalido = false;
                            } 
                       }               
                }
                if (invalido){dialogos.errorVelocidadT();}
            } while(invalido);
            
            do{
                try{
                    dialogos.velocidadT4();
                    Scanner tecInt = new Scanner(System.in);
                    peso = tecInt.nextInt();
                    if(peso<0||peso>1000){
                        System.out.println("ERROR, Tamaño no Permitido.");
                        peso=0;
                    }
                    invalido = false;
                }catch(Exception e){
                    System.out.println(eEx);
                    invalido = true;
                }
            }while(invalido);
        }
        return vRed;
    }

    /**
     *
     * @return unica
     */
    public int getUnica() {
        return unica;
    }
    
    /**
     *
     * @return equipo1
     */
    public String getEquipo1(){
        return equipo1;
    }
    
    /**
     *
     * @return equipo2
     */
    public String getEquipo2(){
        return equipo2;
    }
    
    /**
     *
     * @return graph
     */
    public Graph getGrafo(){
        return graph;
    }

    /**
     *
     * @return peso
     */
    public int getPeso(){
        return peso;
    }
    
    /**
     *
     * @param cantC
     */
    public void setCantC(int cantC) {
        this.cantC = cantC;
    }
    
    /**
     *
     * @param ingresoC
     */
    public void setIngresoC(int ingresoC) {
        this.ingresoC = ingresoC;
    }

    /**
     *
     * @param tipoE
     */
    public void setTipoE(int tipoE) {
        this.tipoE = tipoE;
    }

    /**
     *
     * @param cEcono
     */
    public void setcEcono(int cEcono) {
        this.cEcono = cEcono;
    }

    /**
     *
     * @return cEcono
     */
    public int getcEcono() {
        return cEcono;
    }
    
    /**
     *
     * @return ingresoC
     */
    public int getIngresoC(){
        return ingresoC;
    }

    /**
     *
     * @return tipoDesk
     */
    public int getTipoDesk() {
        return tipoDesk;
    }

    /**
     *
     * @return tipoLap
     */
    public int getTipoLap() {
        return tipoLap;
    }

    /**
     *
     * @return a
     */
    public int getA() {
        return a;
    }

    /**
     *
     * @return nombreE
     */
    public String getNombreE() {
        return nombreE;
    }

}
